﻿using System;
using System.ComponentModel;
using System.Runtime.InteropServices;

namespace Teigha.Core
{
	public class OdGsViewImpl : OdGsView
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public OdGsViewImpl(IntPtr cPtr, bool cMemoryOwn) : base(GlobalsPINVOKE.OdGsViewImpl_SWIGUpcast(cPtr), cMemoryOwn)
		{
			this.swigCPtr = new HandleRef(this, cPtr);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public static HandleRef getCPtr(OdGsViewImpl obj)
		{
			if (obj != null)
			{
				return obj.swigCPtr;
			}
			return new HandleRef(null, IntPtr.Zero);
		}

		~OdGsViewImpl()
		{
			this.Dispose();
		}

		public new virtual void Dispose()
		{
			if (this.swigCPtr.Handle != IntPtr.Zero)
			{
				if (this.swigCMemOwn)
				{
					lock (this.locker)
					{
						if (this.swigCPtr.Handle != IntPtr.Zero && this.swigCMemOwn)
						{
							this.swigCMemOwn = false;
							GlobalsPINVOKE.delete_OdGsViewImpl(this.swigCPtr);
						}
					}
					this.swigCMemOwn = false;
				}
				this.swigCPtr = new HandleRef(null, IntPtr.Zero);
			}
			GC.SuppressFinalize(this);
		}

		public new static OdGsViewImpl cast(OdRxObject pObj)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = GlobalsPINVOKE.OdGsViewImpl_cast(OdRxObject.getCPtr(pObj));
			OdGsViewImpl result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdGsViewImpl)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdGsViewImpl)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdGsViewImpl)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new static OdRxClass desc()
		{
			OdRxClass result = (OdRxClass)Teigha.Core.Helpers.odrxCreateObjectInternal(GlobalsPINVOKE.OdGsViewImpl_desc(), false);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual OdRxClass isA()
		{
			OdRxClass result = (OdRxClass)Teigha.Core.Helpers.odrxCreateObjectInternal(GlobalsPINVOKE.OdGsViewImpl_isA(this.swigCPtr), false);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual OdRxObject queryX(OdRxClass protocolClass)
		{
			OdRxObject result = Teigha.Core.Helpers.odrxCreateObjectInternal(GlobalsPINVOKE.OdGsViewImpl_queryX(this.swigCPtr, OdRxClass.getCPtr(protocolClass)), false);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new static OdGsViewImpl createObject()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = GlobalsPINVOKE.OdGsViewImpl_createObject();
			OdGsViewImpl result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdGsViewImpl)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdGsViewImpl)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdGsViewImpl)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual void setUserGiContext(OdGiContext pUserGiContext)
		{
			GlobalsPINVOKE.OdGsViewImpl_setUserGiContext(this.swigCPtr, OdGiContext.getCPtr(pUserGiContext));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void update()
		{
			GlobalsPINVOKE.OdGsViewImpl_update(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void init(OdGsBaseVectorizeDevice pDevice, OdGsClientViewInfo pViewInfo, bool enableLayerVisibilityPerView)
		{
			GlobalsPINVOKE.OdGsViewImpl_init__SWIG_0(this.swigCPtr, OdGsBaseVectorizeDevice.getCPtr(pDevice), OdGsClientViewInfo.getCPtr(pViewInfo), enableLayerVisibilityPerView);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void init(OdGsBaseVectorizeDevice pDevice, OdGsClientViewInfo pViewInfo)
		{
			GlobalsPINVOKE.OdGsViewImpl_init__SWIG_1(this.swigCPtr, OdGsBaseVectorizeDevice.getCPtr(pDevice), OdGsClientViewInfo.getCPtr(pViewInfo));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void init(OdGsBaseVectorizeDevice pDevice)
		{
			GlobalsPINVOKE.OdGsViewImpl_init__SWIG_2(this.swigCPtr, OdGsBaseVectorizeDevice.getCPtr(pDevice));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual OdGsDevice device()
		{
			OdGsDevice result = (OdGsDevice)Teigha.Core.Helpers.odrxCreateObjectInternal(GlobalsPINVOKE.OdGsViewImpl_device(this.swigCPtr), false);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual OdGsView.RenderMode mode()
		{
			OdGsView.RenderMode result = (OdGsView.RenderMode)GlobalsPINVOKE.OdGsViewImpl_mode(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool setModeOverride(OdGsView.RenderMode mode)
		{
			bool result = GlobalsPINVOKE.OdGsViewImpl_setModeOverride(this.swigCPtr, (int)mode);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual void setMode(OdGsView.RenderMode mode)
		{
			GlobalsPINVOKE.OdGsViewImpl_setMode(this.swigCPtr, (int)mode);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void freezeLayer(OdDbStub layerID)
		{
			GlobalsPINVOKE.OdGsViewImpl_freezeLayer(this.swigCPtr, OdDbStub.getCPtr(layerID));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void thawLayer(OdDbStub layerID)
		{
			GlobalsPINVOKE.OdGsViewImpl_thawLayer(this.swigCPtr, OdDbStub.getCPtr(layerID));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void clearFrozenLayers()
		{
			GlobalsPINVOKE.OdGsViewImpl_clearFrozenLayers(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void setViewportBorderProperties(uint color, int width)
		{
			GlobalsPINVOKE.OdGsViewImpl_setViewportBorderProperties(this.swigCPtr, color, width);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void getViewportBorderProperties(out uint color, out int width)
		{
			GlobalsPINVOKE.OdGsViewImpl_getViewportBorderProperties(this.swigCPtr, out color, out width);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void setViewportBorderVisibility(bool visible)
		{
			GlobalsPINVOKE.OdGsViewImpl_setViewportBorderVisibility(this.swigCPtr, visible);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual bool isViewportBorderVisible()
		{
			bool result = GlobalsPINVOKE.OdGsViewImpl_isViewportBorderVisible(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual void setEnableFrontClip(bool enable)
		{
			GlobalsPINVOKE.OdGsViewImpl_setEnableFrontClip(this.swigCPtr, enable);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual bool isFrontClipped()
		{
			bool result = GlobalsPINVOKE.OdGsViewImpl_isFrontClipped(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual void setFrontClip(double distance)
		{
			GlobalsPINVOKE.OdGsViewImpl_setFrontClip(this.swigCPtr, distance);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual double frontClip()
		{
			double result = GlobalsPINVOKE.OdGsViewImpl_frontClip(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual void setEnableBackClip(bool enable)
		{
			GlobalsPINVOKE.OdGsViewImpl_setEnableBackClip(this.swigCPtr, enable);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual bool isBackClipped()
		{
			bool result = GlobalsPINVOKE.OdGsViewImpl_isBackClipped(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual void setBackClip(double distance)
		{
			GlobalsPINVOKE.OdGsViewImpl_setBackClip(this.swigCPtr, distance);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual double backClip()
		{
			double result = GlobalsPINVOKE.OdGsViewImpl_backClip(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual OdGePoint3d position()
		{
			OdGePoint3d result = new OdGePoint3d(GlobalsPINVOKE.OdGsViewImpl_position(this.swigCPtr), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual OdGePoint3d target()
		{
			OdGePoint3d result = new OdGePoint3d(GlobalsPINVOKE.OdGsViewImpl_target(this.swigCPtr), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual OdGeVector3d upVector()
		{
			OdGeVector3d result = new OdGeVector3d(GlobalsPINVOKE.OdGsViewImpl_upVector(this.swigCPtr), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual double fieldWidth()
		{
			double result = GlobalsPINVOKE.OdGsViewImpl_fieldWidth(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual double fieldHeight()
		{
			double result = GlobalsPINVOKE.OdGsViewImpl_fieldHeight(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public double windowAspect()
		{
			double result = GlobalsPINVOKE.OdGsViewImpl_windowAspect(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual double lensLength()
		{
			double result = GlobalsPINVOKE.OdGsViewImpl_lensLength(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual void setLensLength(double lensLength)
		{
			GlobalsPINVOKE.OdGsViewImpl_setLensLength(this.swigCPtr, lensLength);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual bool isPerspective()
		{
			bool result = GlobalsPINVOKE.OdGsViewImpl_isPerspective(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual void beginInteractivity(double frameRateInHz)
		{
			GlobalsPINVOKE.OdGsViewImpl_beginInteractivity(this.swigCPtr, frameRateInHz);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void endInteractivity()
		{
			GlobalsPINVOKE.OdGsViewImpl_endInteractivity(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void flush()
		{
			GlobalsPINVOKE.OdGsViewImpl_flush(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void hide()
		{
			GlobalsPINVOKE.OdGsViewImpl_hide(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void show()
		{
			GlobalsPINVOKE.OdGsViewImpl_show(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual bool isVisible()
		{
			bool result = GlobalsPINVOKE.OdGsViewImpl_isVisible(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual OdGsView cloneView(bool cloneViewParameters, bool cloneGeometry)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = GlobalsPINVOKE.OdGsViewImpl_cloneView__SWIG_0(this.swigCPtr, cloneViewParameters, cloneGeometry);
			OdGsView result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdGsView)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdGsView)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdGsView)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual OdGsView cloneView(bool cloneViewParameters)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = GlobalsPINVOKE.OdGsViewImpl_cloneView__SWIG_1(this.swigCPtr, cloneViewParameters);
			OdGsView result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdGsView)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdGsView)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdGsView)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual OdGsView cloneView()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = GlobalsPINVOKE.OdGsViewImpl_cloneView__SWIG_2(this.swigCPtr);
			OdGsView result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdGsView)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdGsView)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdGsView)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual bool exceededBounds()
		{
			bool result = GlobalsPINVOKE.OdGsViewImpl_exceededBounds(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual void enableStereo(bool enabled)
		{
			GlobalsPINVOKE.OdGsViewImpl_enableStereo(this.swigCPtr, enabled);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual bool isStereoEnabled()
		{
			bool result = GlobalsPINVOKE.OdGsViewImpl_isStereoEnabled(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual void setStereoParameters(double magnitude, double parallax)
		{
			GlobalsPINVOKE.OdGsViewImpl_setStereoParameters(this.swigCPtr, magnitude, parallax);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void getStereoParameters(out double magnitude, out double parallax)
		{
			GlobalsPINVOKE.OdGsViewImpl_getStereoParameters(this.swigCPtr, out magnitude, out parallax);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void initLights(OdRxIterator pLightsIterator)
		{
			GlobalsPINVOKE.OdGsViewImpl_initLights(this.swigCPtr, OdRxIterator.getCPtr(pLightsIterator));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void getSnapShot(out OdGiRasterImage pImage, OdGsDCRect region)
		{
			IntPtr zero = IntPtr.Zero;
			try
			{
				GlobalsPINVOKE.OdGsViewImpl_getSnapShot(this.swigCPtr, out zero, OdGsDCRect.getCPtr(region));
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
			}
			finally
			{
				pImage = (OdGiRasterImage)Teigha.Core.Helpers.odrxCreateObjectInternal(zero, true);
			}
		}

		public new virtual void setViewport(OdGePoint2d lowerLeft, OdGePoint2d upperRight)
		{
			GlobalsPINVOKE.OdGsViewImpl_setViewport__SWIG_0(this.swigCPtr, OdGePoint2d.getCPtr(lowerLeft), OdGePoint2d.getCPtr(upperRight));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void setViewport(OdGsDCRect screenRect)
		{
			GlobalsPINVOKE.OdGsViewImpl_setViewport__SWIG_1(this.swigCPtr, OdGsDCRect.getCPtr(screenRect));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void setViewport(OdGsDCRectDouble screenRec)
		{
			GlobalsPINVOKE.OdGsViewImpl_setViewport__SWIG_2(this.swigCPtr, OdGsDCRectDouble.getCPtr(screenRec));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void getViewport(OdGePoint2d lowerLeft, OdGePoint2d upperRight)
		{
			GlobalsPINVOKE.OdGsViewImpl_getViewport__SWIG_0(this.swigCPtr, OdGePoint2d.getCPtr(lowerLeft), OdGePoint2d.getCPtr(upperRight));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void getViewport(OdGsDCRect screenRect)
		{
			GlobalsPINVOKE.OdGsViewImpl_getViewport__SWIG_1(this.swigCPtr, OdGsDCRect.getCPtr(screenRect));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void getViewport(OdGsDCRectDouble screenRec)
		{
			GlobalsPINVOKE.OdGsViewImpl_getViewport__SWIG_2(this.swigCPtr, OdGsDCRectDouble.getCPtr(screenRec));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual OdGeMatrix3d screenMatrix()
		{
			OdGeMatrix3d result = new OdGeMatrix3d(GlobalsPINVOKE.OdGsViewImpl_screenMatrix(this.swigCPtr), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual OdGeMatrix3d worldToDeviceMatrix()
		{
			OdGeMatrix3d result = new OdGeMatrix3d(GlobalsPINVOKE.OdGsViewImpl_worldToDeviceMatrix(this.swigCPtr), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual OdGeMatrix3d objectToDeviceMatrix()
		{
			OdGeMatrix3d result = new OdGeMatrix3d(GlobalsPINVOKE.OdGsViewImpl_objectToDeviceMatrix(this.swigCPtr), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual OdGeMatrix3d viewingMatrix()
		{
			OdGeMatrix3d result = new OdGeMatrix3d(GlobalsPINVOKE.OdGsViewImpl_viewingMatrix(this.swigCPtr), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual OdGeMatrix3d projectionMatrix()
		{
			OdGeMatrix3d result = new OdGeMatrix3d(GlobalsPINVOKE.OdGsViewImpl_projectionMatrix(this.swigCPtr), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual void viewParameters(OdGsView pView)
		{
			GlobalsPINVOKE.OdGsViewImpl_viewParameters(this.swigCPtr, OdGsView.getCPtr(pView));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual double lineweightToDcScale()
		{
			double result = GlobalsPINVOKE.OdGsViewImpl_lineweightToDcScale(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual void setLineweightToDcScale(double scale)
		{
			GlobalsPINVOKE.OdGsViewImpl_setLineweightToDcScale(this.swigCPtr, scale);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void setLineweightEnum(byte[] numLineweights)
		{
			IntPtr intPtr = Teigha.Core.Helpers.MarshalbyteFixedArray(numLineweights);
			try
			{
				GlobalsPINVOKE.OdGsViewImpl_setLineweightEnum(this.swigCPtr, intPtr);
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
			}
			finally
			{
				Marshal.FreeCoTaskMem(intPtr);
			}
		}

		public new virtual void setLinetypeScaleMultiplier(double linetypeScaleMultiplier)
		{
			GlobalsPINVOKE.OdGsViewImpl_setLinetypeScaleMultiplier(this.swigCPtr, linetypeScaleMultiplier);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void setAlternateLinetypeScaleMultiplier(double linetypeAlternateScaleMultiplier)
		{
			GlobalsPINVOKE.OdGsViewImpl_setAlternateLinetypeScaleMultiplier(this.swigCPtr, linetypeAlternateScaleMultiplier);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual double linetypeScaleMultiplier()
		{
			double result = GlobalsPINVOKE.OdGsViewImpl_linetypeScaleMultiplier(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual void dolly(OdGeVector3d dollyVector)
		{
			GlobalsPINVOKE.OdGsViewImpl_dolly__SWIG_0(this.swigCPtr, OdGeVector3d.getCPtr(dollyVector));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void dolly(double xDolly, double yDolly, double zDolly)
		{
			GlobalsPINVOKE.OdGsViewImpl_dolly__SWIG_1(this.swigCPtr, xDolly, yDolly, zDolly);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void roll(double rollAngle)
		{
			GlobalsPINVOKE.OdGsViewImpl_roll(this.swigCPtr, rollAngle);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void orbit(double xOrbit, double yOrbit)
		{
			GlobalsPINVOKE.OdGsViewImpl_orbit(this.swigCPtr, xOrbit, yOrbit);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void zoom(double zoomFactor)
		{
			GlobalsPINVOKE.OdGsViewImpl_zoom(this.swigCPtr, zoomFactor);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void pan(double xPan, double yPan)
		{
			GlobalsPINVOKE.OdGsViewImpl_pan(this.swigCPtr, xPan, yPan);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void setView(OdGePoint3d position, OdGePoint3d target, OdGeVector3d upVector, double fieldWidth, double fieldHeight, OdGsView.Projection projection)
		{
			GlobalsPINVOKE.OdGsViewImpl_setView__SWIG_0(this.swigCPtr, OdGePoint3d.getCPtr(position), OdGePoint3d.getCPtr(target), OdGeVector3d.getCPtr(upVector), fieldWidth, fieldHeight, (int)projection);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void setView(OdGePoint3d position, OdGePoint3d target, OdGeVector3d upVector, double fieldWidth, double fieldHeight)
		{
			GlobalsPINVOKE.OdGsViewImpl_setView__SWIG_1(this.swigCPtr, OdGePoint3d.getCPtr(position), OdGePoint3d.getCPtr(target), OdGeVector3d.getCPtr(upVector), fieldWidth, fieldHeight);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void zoomExtents(OdGePoint3d minPt, OdGePoint3d maxPt)
		{
			GlobalsPINVOKE.OdGsViewImpl_zoomExtents(this.swigCPtr, OdGePoint3d.getCPtr(minPt), OdGePoint3d.getCPtr(maxPt));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void zoomWindow(OdGePoint2d lowerLeft, OdGePoint2d upperRight)
		{
			GlobalsPINVOKE.OdGsViewImpl_zoomWindow(this.swigCPtr, OdGePoint2d.getCPtr(lowerLeft), OdGePoint2d.getCPtr(upperRight));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual bool pointInView(OdGePoint3d pt)
		{
			bool result = GlobalsPINVOKE.OdGsViewImpl_pointInView(this.swigCPtr, OdGePoint3d.getCPtr(pt));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual bool extentsInView(OdGePoint3d minPt, OdGePoint3d maxPt)
		{
			bool result = GlobalsPINVOKE.OdGsViewImpl_extentsInView(this.swigCPtr, OdGePoint3d.getCPtr(minPt), OdGePoint3d.getCPtr(maxPt));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual void viewportClipRegion(OdIntArray counts, OdGePoint2dArray vertices)
		{
			GlobalsPINVOKE.OdGsViewImpl_viewportClipRegion__SWIG_0(this.swigCPtr, OdIntArray.getCPtr(counts).Handle, OdGePoint2dArray.getCPtr(vertices).Handle);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void viewportClipRegion(OdIntArray counts, OdGsDCPointArray dcPts)
		{
			GlobalsPINVOKE.OdGsViewImpl_viewportClipRegion__SWIG_1(this.swigCPtr, OdIntArray.getCPtr(counts).Handle, OdGsDCPointArray.getCPtr(dcPts).Handle);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void setViewportClipRegion(OdGePoint2dArray[] numContours)
		{
			IntPtr intPtr = Helpers.MarshalClipRegion(numContours);
			try
			{
				GlobalsPINVOKE.OdGsViewImpl_setViewportClipRegion__SWIG_0(this.swigCPtr, intPtr);
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
			}
			finally
			{
				Marshal.FreeCoTaskMem(intPtr);
			}
		}

		public new virtual void setViewportClipRegion(int numContours, SWIGTYPE_p_int numVertices, OdGsDCPoint vertices)
		{
			GlobalsPINVOKE.OdGsViewImpl_setViewportClipRegion__SWIG_1(this.swigCPtr, numContours, SWIGTYPE_p_int.getCPtr(numVertices), OdGsDCPoint.getCPtr(vertices));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdGsBaseModule getGsModulePtr()
		{
			OdGsBaseModule result = (OdGsBaseModule)Teigha.Core.Helpers.odrxCreateObjectInternal(GlobalsPINVOKE.OdGsViewImpl_getGsModulePtr(this.swigCPtr), false);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdGiContextualColors contextualColors()
		{
			OdGiContextualColors result = (OdGiContextualColors)Teigha.Core.Helpers.odrxCreateObjectInternal(GlobalsPINVOKE.OdGsViewImpl_contextualColors(this.swigCPtr), false);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setContextualColors(OdGiContextualColors pColors)
		{
			GlobalsPINVOKE.OdGsViewImpl_setContextualColors(this.swigCPtr, OdGiContextualColors.getCPtr(pColors));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual bool pointInViewport(OdGePoint2d screenPoint)
		{
			bool result = GlobalsPINVOKE.OdGsViewImpl_pointInViewport(this.swigCPtr, OdGePoint2d.getCPtr(screenPoint));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual void setClearColor(OdGsView.ClearColor color)
		{
			GlobalsPINVOKE.OdGsViewImpl_setClearColor(this.swigCPtr, (int)color);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void invalidate()
		{
			GlobalsPINVOKE.OdGsViewImpl_invalidate__SWIG_0(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void invalidate(OdGsDCRect rect)
		{
			GlobalsPINVOKE.OdGsViewImpl_invalidate__SWIG_1(this.swigCPtr, OdGsDCRect.getCPtr(rect));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void invalidateCachedViewportGeometry()
		{
			GlobalsPINVOKE.OdGsViewImpl_invalidateCachedViewportGeometry__SWIG_0(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void select(OdGsDCPoint[] points, OdGsSelectionReactor pReactor, OdGsView.SelectionMode mode)
		{
			IntPtr intPtr = Helpers.MarshalOdGsDCPointArray(points);
			try
			{
				GlobalsPINVOKE.OdGsViewImpl_select__SWIG_0(this.swigCPtr, intPtr, OdGsSelectionReactor.getCPtr(pReactor), (int)mode);
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
			}
			finally
			{
				Marshal.FreeCoTaskMem(intPtr);
			}
		}

		public new virtual bool add(OdGiDrawable sceneGraph, OdGsModel model)
		{
			bool result = GlobalsPINVOKE.OdGsViewImpl_add(this.swigCPtr, OdGiDrawable.getCPtr(sceneGraph), OdGsModel.getCPtr(model));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual bool erase(OdGiDrawable sceneGraph)
		{
			bool result = GlobalsPINVOKE.OdGsViewImpl_erase(this.swigCPtr, OdGiDrawable.getCPtr(sceneGraph));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual void eraseAll()
		{
			GlobalsPINVOKE.OdGsViewImpl_eraseAll(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual OdGsModel getModel(OdGiDrawable pDrawable)
		{
			OdGsModel result = (OdGsModel)Teigha.Core.Helpers.odrxCreateObjectInternal(GlobalsPINVOKE.OdGsViewImpl_getModel(this.swigCPtr, OdGiDrawable.getCPtr(pDrawable)), false);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual SWIGTYPE_p_OdArrayT_OdGsModel_p_OdMemoryAllocatorT_OdGsModel_p_t_t getModelList()
		{
			SWIGTYPE_p_OdArrayT_OdGsModel_p_OdMemoryAllocatorT_OdGsModel_p_t_t result = new SWIGTYPE_p_OdArrayT_OdGsModel_p_OdMemoryAllocatorT_OdGsModel_p_t_t(GlobalsPINVOKE.OdGsViewImpl_getModelList(this.swigCPtr), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual bool isValid()
		{
			bool result = GlobalsPINVOKE.OdGsViewImpl_isValid(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual void getNumPixelsInUnitSquare(OdGePoint3d givenWorldpt, OdGePoint2d pixelArea, bool includePerspective)
		{
			GlobalsPINVOKE.OdGsViewImpl_getNumPixelsInUnitSquare__SWIG_0(this.swigCPtr, OdGePoint3d.getCPtr(givenWorldpt), OdGePoint2d.getCPtr(pixelArea), includePerspective);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void getNumPixelsInUnitSquare(OdGePoint3d givenWorldpt, OdGePoint2d pixelArea)
		{
			GlobalsPINVOKE.OdGsViewImpl_getNumPixelsInUnitSquare__SWIG_1(this.swigCPtr, OdGePoint3d.getCPtr(givenWorldpt), OdGePoint2d.getCPtr(pixelArea));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void setBackground(OdDbStub backgroundId)
		{
			GlobalsPINVOKE.OdGsViewImpl_setBackground(this.swigCPtr, OdDbStub.getCPtr(backgroundId));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual OdDbStub background()
		{
			IntPtr intPtr = GlobalsPINVOKE.OdGsViewImpl_background(this.swigCPtr);
			OdDbStub result = (intPtr == IntPtr.Zero) ? null : new OdDbStub(intPtr, false);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual void setVisualStyle(OdDbStub visualStyleId)
		{
			GlobalsPINVOKE.OdGsViewImpl_setVisualStyle__SWIG_0(this.swigCPtr, OdDbStub.getCPtr(visualStyleId));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual OdDbStub visualStyle()
		{
			IntPtr intPtr = GlobalsPINVOKE.OdGsViewImpl_visualStyle__SWIG_0(this.swigCPtr);
			OdDbStub result = (intPtr == IntPtr.Zero) ? null : new OdDbStub(intPtr, false);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual void setVisualStyle(OdGiVisualStyle visualStyle)
		{
			GlobalsPINVOKE.OdGsViewImpl_setVisualStyle__SWIG_1(this.swigCPtr, OdGiVisualStyle.getCPtr(visualStyle));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual bool visualStyle(OdGiVisualStyle vs)
		{
			bool result = GlobalsPINVOKE.OdGsViewImpl_visualStyle__SWIG_1(this.swigCPtr, OdGiVisualStyle.getCPtr(vs));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdGsViewImpl safeCast(OdGsView pView)
		{
			OdGsViewImpl result = (OdGsViewImpl)Teigha.Core.Helpers.odrxCreateObjectInternal(GlobalsPINVOKE.OdGsViewImpl_safeCast__SWIG_0(OdGsView.getCPtr(pView)), false);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public uint viewportId()
		{
			uint result = GlobalsPINVOKE.OdGsViewImpl_viewportId(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdGsBaseVectorizeDevice baseDevice()
		{
			OdGsBaseVectorizeDevice result = (OdGsBaseVectorizeDevice)Teigha.Core.Helpers.odrxCreateObjectInternal(GlobalsPINVOKE.OdGsViewImpl_baseDevice__SWIG_0(this.swigCPtr), false);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbStub annotationScaleId()
		{
			IntPtr intPtr = GlobalsPINVOKE.OdGsViewImpl_annotationScaleId(this.swigCPtr);
			OdDbStub result = (intPtr == IntPtr.Zero) ? null : new OdDbStub(intPtr, false);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public IntPtr drawablesFilterFunction()
		{
			IntPtr result = GlobalsPINVOKE.OdGsViewImpl_drawablesFilterFunction(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual bool viewExtents(OdGeBoundBlock3d extents)
		{
			bool result = GlobalsPINVOKE.OdGsViewImpl_viewExtents(this.swigCPtr, OdGeBoundBlock3d.getCPtr(extents));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void select(OdGePoint2d[] aPtDc, OdGsSelectionReactor pReactor, OdGsView.SelectionMode mode)
		{
			IntPtr intPtr = Helpers.MarshalPoint2dArray(aPtDc);
			try
			{
				GlobalsPINVOKE.OdGsViewImpl_select__SWIG_1(this.swigCPtr, intPtr, OdGsSelectionReactor.getCPtr(pReactor), (int)mode);
				if (GlobalsPINVOKE.SWIGPendingException.Pending)
				{
					throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
				}
			}
			finally
			{
				Marshal.FreeCoTaskMem(intPtr);
			}
		}

		public bool isRegenOnDrawForbidden()
		{
			bool result = GlobalsPINVOKE.OdGsViewImpl_isRegenOnDrawForbidden(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setRegenOnDrawForbidden(bool val)
		{
			GlobalsPINVOKE.OdGsViewImpl_setRegenOnDrawForbidden(this.swigCPtr, val);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void clearLinetypeCache()
		{
			GlobalsPINVOKE.OdGsViewImpl_clearLinetypeCache(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new double linetypeAlternateScaleMultiplier()
		{
			double result = GlobalsPINVOKE.OdGsViewImpl_linetypeAlternateScaleMultiplier(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual bool isSupportLegacyWireframeMode()
		{
			bool result = GlobalsPINVOKE.OdGsViewImpl_isSupportLegacyWireframeMode(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual bool isLegacyWireframeMode()
		{
			bool result = GlobalsPINVOKE.OdGsViewImpl_isLegacyWireframeMode(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setLegacyWireframeMode(bool bSet)
		{
			GlobalsPINVOKE.OdGsViewImpl_setLegacyWireframeMode(this.swigCPtr, bSet);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool isSupportLegacyHiddenMode()
		{
			bool result = GlobalsPINVOKE.OdGsViewImpl_isSupportLegacyHiddenMode(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual bool isLegacyHiddenMode()
		{
			bool result = GlobalsPINVOKE.OdGsViewImpl_isLegacyHiddenMode(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setLegacyHiddenMode(bool bSet)
		{
			GlobalsPINVOKE.OdGsViewImpl_setLegacyHiddenMode(this.swigCPtr, bSet);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public bool frozenLayers()
		{
			bool result = GlobalsPINVOKE.OdGsViewImpl_frozenLayers__SWIG_0(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void frozenLayers(OdDbStubPtrArray frozenLayers)
		{
			GlobalsPINVOKE.OdGsViewImpl_frozenLayers__SWIG_1(this.swigCPtr, OdDbStubPtrArray.getCPtr(frozenLayers));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public bool isLayerVisible(OdDbStub layerId)
		{
			bool result = GlobalsPINVOKE.OdGsViewImpl_isLayerVisible(this.swigCPtr, OdDbStub.getCPtr(layerId));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void viewportDcCorners(OdGePoint2d lower_left, OdGePoint2d upper_right)
		{
			GlobalsPINVOKE.OdGsViewImpl_viewportDcCorners(this.swigCPtr, OdGePoint2d.getCPtr(lower_left), OdGePoint2d.getCPtr(upper_right));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void invalidate(OdGeExtents3d worldExt, LineWeight extendByLineweight)
		{
			GlobalsPINVOKE.OdGsViewImpl_invalidate__SWIG_2(this.swigCPtr, OdGeExtents3d.getCPtr(worldExt), (int)extendByLineweight);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void invalidate(OdGeExtents3d worldExt)
		{
			GlobalsPINVOKE.OdGsViewImpl_invalidate__SWIG_3(this.swigCPtr, OdGeExtents3d.getCPtr(worldExt));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void invalidateRegion(OdGiPathNode path)
		{
			GlobalsPINVOKE.OdGsViewImpl_invalidateRegion(this.swigCPtr, OdGiPathNode.getCPtr(path));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdGiRegenType getRegenType()
		{
			OdGiRegenType result = (OdGiRegenType)GlobalsPINVOKE.OdGsViewImpl_getRegenType(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public double getLinetypeScaleMultiplier()
		{
			double result = GlobalsPINVOKE.OdGsViewImpl_getLinetypeScaleMultiplier(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public double getLinetypeGenerationCriteria()
		{
			double result = GlobalsPINVOKE.OdGsViewImpl_getLinetypeGenerationCriteria(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual double getDeviation(OdGiDeviationType deviationType, OdGePoint3d pointOnCurve, bool bRecalculate)
		{
			double result = GlobalsPINVOKE.OdGsViewImpl_getDeviation__SWIG_0(this.swigCPtr, (int)deviationType, OdGePoint3d.getCPtr(pointOnCurve), bRecalculate);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual double getDeviation(OdGiDeviationType deviationType, OdGePoint3d pointOnCurve)
		{
			double result = GlobalsPINVOKE.OdGsViewImpl_getDeviation__SWIG_1(this.swigCPtr, (int)deviationType, OdGePoint3d.getCPtr(pointOnCurve));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void initDeviation()
		{
			GlobalsPINVOKE.OdGsViewImpl_initDeviation(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public int cachedDrawables()
		{
			int result = GlobalsPINVOKE.OdGsViewImpl_cachedDrawables(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void invalidateCachedViewportGeometry(uint mask)
		{
			GlobalsPINVOKE.OdGsViewImpl_invalidateCachedViewportGeometry__SWIG_1(this.swigCPtr, mask);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public double calcDeviation(OdGiDeviationType type, OdGePoint3d pt)
		{
			double result = GlobalsPINVOKE.OdGsViewImpl_calcDeviation(this.swigCPtr, (int)type, OdGePoint3d.getCPtr(pt));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdGsProperties getViewportPropertiesRoot()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = GlobalsPINVOKE.OdGsViewImpl_getViewportPropertiesRoot(this.swigCPtr);
			OdGsProperties result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdGsProperties)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdGsProperties)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdGsProperties)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool updateViewportProperties(uint incFlags)
		{
			bool result = GlobalsPINVOKE.OdGsViewImpl_updateViewportProperties(this.swigCPtr, incFlags);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdGsProperties getViewportPropertiesForType(OdGsProperties.PropertiesType type)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = GlobalsPINVOKE.OdGsViewImpl_getViewportPropertiesForType(this.swigCPtr, (int)type);
			OdGsProperties result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdGsProperties)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdGsProperties)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdGsProperties)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void initCullingVolume()
		{
			GlobalsPINVOKE.OdGsViewImpl_initCullingVolume(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void setCullingVolume(OdGsCullingVolume newVol)
		{
			GlobalsPINVOKE.OdGsViewImpl_setCullingVolume(this.swigCPtr, OdGsCullingVolume.getCPtr(newVol));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdGsCullingVolume cullingVolume()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = GlobalsPINVOKE.OdGsViewImpl_cullingVolume(this.swigCPtr);
			OdGsCullingVolume result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdGsCullingVolume)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdGsCullingVolume)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdGsCullingVolume)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual bool isCullingVolumeInitialized()
		{
			bool result = GlobalsPINVOKE.OdGsViewImpl_isCullingVolumeInitialized(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual bool cullingVolumeIntersectWithOpt(OdGsCullingPrimitiveImpl prim)
		{
			bool result = GlobalsPINVOKE.OdGsViewImpl_cullingVolumeIntersectWithOpt(this.swigCPtr, OdGsCullingPrimitiveImpl.getCPtr(prim));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdGsCullingVolume.IntersectionStatus cullingVolumeIntersectWith(OdGsCullingPrimitiveImpl prim)
		{
			OdGsCullingVolume.IntersectionStatus result = (OdGsCullingVolume.IntersectionStatus)GlobalsPINVOKE.OdGsViewImpl_cullingVolumeIntersectWith(this.swigCPtr, OdGsCullingPrimitiveImpl.getCPtr(prim));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void cullingVolumeTransformBy(OdGeMatrix3d xfm)
		{
			GlobalsPINVOKE.OdGsViewImpl_cullingVolumeTransformBy(this.swigCPtr, OdGeMatrix3d.getCPtr(xfm));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void setViewport3dClipping(OdGiClipBoundary pBoundary, OdGiAbstractClipBoundary pClipInfo)
		{
			GlobalsPINVOKE.OdGsViewImpl_setViewport3dClipping__SWIG_0(this.swigCPtr, OdGiClipBoundary.getCPtr(pBoundary), OdGiAbstractClipBoundary.getCPtr(pClipInfo));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void setViewport3dClipping(OdGiClipBoundary pBoundary)
		{
			GlobalsPINVOKE.OdGsViewImpl_setViewport3dClipping__SWIG_1(this.swigCPtr, OdGiClipBoundary.getCPtr(pBoundary));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual OdGiClipBoundary viewport3dClipping(SWIGTYPE_p_p_OdGiAbstractClipBoundary ppClipInfo)
		{
			IntPtr intPtr = GlobalsPINVOKE.OdGsViewImpl_viewport3dClipping__SWIG_0(this.swigCPtr, SWIGTYPE_p_p_OdGiAbstractClipBoundary.getCPtr(ppClipInfo));
			OdGiClipBoundary result = (intPtr == IntPtr.Zero) ? null : new OdGiClipBoundary(intPtr, false);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual OdGiClipBoundary viewport3dClipping()
		{
			IntPtr intPtr = GlobalsPINVOKE.OdGsViewImpl_viewport3dClipping__SWIG_1(this.swigCPtr);
			OdGiClipBoundary result = (intPtr == IntPtr.Zero) ? null : new OdGiClipBoundary(intPtr, false);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdGiClipBoundaryWithAbstractData viewport3dClippingObject()
		{
			IntPtr intPtr = GlobalsPINVOKE.OdGsViewImpl_viewport3dClippingObject(this.swigCPtr);
			OdGiClipBoundaryWithAbstractData result = (intPtr == IntPtr.Zero) ? null : new OdGiClipBoundaryWithAbstractData(intPtr, false);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool hasViewport3dClipping()
		{
			bool result = GlobalsPINVOKE.OdGsViewImpl_hasViewport3dClipping(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual bool saveViewState(SWIGTYPE_p_OdGsFiler pFiler)
		{
			bool result = GlobalsPINVOKE.OdGsViewImpl_saveViewState(this.swigCPtr, SWIGTYPE_p_OdGsFiler.getCPtr(pFiler));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual bool loadViewState(SWIGTYPE_p_OdGsFiler pFiler)
		{
			bool result = GlobalsPINVOKE.OdGsViewImpl_loadViewState(this.swigCPtr, SWIGTYPE_p_OdGsFiler.getCPtr(pFiler));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual bool saveClientViewState(SWIGTYPE_p_OdGsFiler pFiler)
		{
			bool result = GlobalsPINVOKE.OdGsViewImpl_saveClientViewState(this.swigCPtr, SWIGTYPE_p_OdGsFiler.getCPtr(pFiler));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual bool loadClientViewState(SWIGTYPE_p_OdGsFiler pFiler)
		{
			bool result = GlobalsPINVOKE.OdGsViewImpl_loadClientViewState(this.swigCPtr, SWIGTYPE_p_OdGsFiler.getCPtr(pFiler));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public int lineweightToPixels(LineWeight lw)
		{
			int result = GlobalsPINVOKE.OdGsViewImpl_lineweightToPixels(this.swigCPtr, (int)lw);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdGeMatrix3d eyeToScreenMatrix()
		{
			OdGeMatrix3d result = new OdGeMatrix3d(GlobalsPINVOKE.OdGsViewImpl_eyeToScreenMatrix(this.swigCPtr), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		private object locker = new object();

		private HandleRef swigCPtr;
	}
}
